home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / ELECTRIC / DSPICE0S.ZIP / matptr.c < prev    next >
C/C++ Source or Header  |  1992-11-22  |  30KB  |  929 lines
  1. /* matptr.f -- translated by f2c (version of 3 February 1990  3:36:42).
  2.    You must link the resulting object file with the libraries:
  3.     -lF77 -lI77 -lm -lc   (in that order)
  4. */
  5.  
  6. #include "f2c.h"
  7.  
  8. /* Common Block Declarations */
  9.  
  10. struct {
  11.     integer ielmnt, isbckt, nsbckt, iunsat, nunsat, itemps, numtem, isens, 
  12.         nsens, ifour, nfour, ifield, icode, idelim, icolum, insize, 
  13.         junode, lsbkpt, numbkp, iorder, jmnode, iur, iuc, ilc, ilr, 
  14.         numoff, isr, nmoffc, iseq, iseq1, neqn, nodevs, ndiag, iswap, 
  15.         iequa, macins, lvnim1, lx0, lvn, lynl, lyu, lyl, lx1, lx2, lx3, 
  16.         lx4, lx5, lx6, lx7, ld0, ld1, ltd, imynl, imvn, lcvn, nsnod, 
  17.         nsmat, nsval, icnod, icmat, icval, loutpt, lpol, lzer, irswpf, 
  18.         irswpr, icswpf, icswpr, irpt, jcpt, irowno, jcolno, nttbr, nttar, 
  19.         lvntmp;
  20. } tabinf_;
  21.  
  22. #define tabinf_1 tabinf_
  23.  
  24. struct {
  25.     integer locate[50], jelcnt[50], nunods, ncnods, numnod, nstop, nut, nlt, 
  26.         nxtrm, ndist, ntlin, ibr, numvs, numalt, numcyc;
  27. } cirdat_;
  28.  
  29. #define cirdat_1 cirdat_
  30.  
  31. struct {
  32.     doublereal value[200000];
  33. } blank_;
  34.  
  35. #define blank_1 blank_
  36.  
  37. /*<       subroutine matptr >*/
  38. /* Subroutine */ int matptr_()
  39. {
  40.     /* System generated locals */
  41.     integer i_1;
  42.  
  43.     /* Local variables */
  44.     static doublereal cdis;
  45.     static integer node, ndim, locm, locn, node1, node2, node3, ndim2, node4, 
  46.         node5, node6, node7;
  47.     extern /* Subroutine */ int getm4_(), zero4_();
  48.     static integer i, ntemp, locvs;
  49. #define nodplc ((integer *)&blank_1)
  50. #define cvalue ((complex *)&blank_1)
  51.     extern /* Subroutine */ int crunch_(), slpmem_(), reserv_();
  52.     static integer nl1, nl2, locvst, ni1, ni2, loc, kbr, ibr1, ibr2;
  53.  
  54. /*<       implicit double precision (a-h,o-z) >*/
  55.  
  56. /*     this routine (by calls to the routine reserve) establishes the */
  57. /* nonzero-element structure of the circuit equation coefficient matrix. 
  58. */
  59.  
  60. /* spice version 2g.6  sccsid=tabinf 3/15/83 */
  61. /*<       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, >*/
  62. /*<      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, >*/
  63. /*<      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, >*/
  64. /*<      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, >*/
  65. /*<      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, >*/
  66. /*<      5   imynl,imvn,lcvn,nsnod,nsmat,nsval,icnod,icmat,icval, >*/
  67. /*<      6   loutpt,lpol,lzer,irswpf,irswpr,icswpf,icswpr,irpt,jcpt, >*/
  68. /*<      7   irowno,jcolno,nttbr,nttar,lvntmp >*/
  69. /* spice version 2g.6  sccsid=cirdat 3/15/83 */
  70. /*<       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, >*/
  71. /*<      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs,numalt,numcyc >*/
  72. /* spice version 2g.6  sccsid=blank 3/15/83 */
  73. /*<       common /blank/ value(200000) >*/
  74. /*<       integer nodplc(64) >*/
  75. /*<       complex cvalue(32) >*/
  76. /*<       equivalence (value(1),nodplc(1),cvalue(1)) >*/
  77.  
  78. /*  allocate and initialize storage */
  79.  
  80. /*<       call getm4(isr,nstop+1) >*/
  81.     i_1 = cirdat_1.nstop + 1;
  82.     getm4_(&tabinf_1.isr, &i_1);
  83. /*<       numvs=jelcnt(3)+jelcnt(6)+jelcnt(8)+jelcnt(9)+2*jelcnt(17) >*/
  84.     cirdat_1.numvs = cirdat_1.jelcnt[2] + cirdat_1.jelcnt[5] + 
  85.         cirdat_1.jelcnt[7] + cirdat_1.jelcnt[8] + (cirdat_1.jelcnt[16] << 
  86.         1);
  87. /*<       call getm4(iseq,numvs) >*/
  88.     getm4_(&tabinf_1.iseq, &cirdat_1.numvs);
  89. /*<       call getm4(iseq1,numvs) >*/
  90.     getm4_(&tabinf_1.iseq1, &cirdat_1.numvs);
  91. /*<       call getm4(neqn,numvs) >*/
  92.     getm4_(&tabinf_1.neqn, &cirdat_1.numvs);
  93. /*<       call getm4(nodevs,numnod) >*/
  94.     getm4_(&tabinf_1.nodevs, &cirdat_1.numnod);
  95. /*<       call getm4(ndiag,nstop) >*/
  96.     getm4_(&tabinf_1.ndiag, &cirdat_1.nstop);
  97. /*<       call getm4(nmoffc,nstop) >*/
  98.     getm4_(&tabinf_1.nmoffc, &cirdat_1.nstop);
  99. /*<       call getm4(numoff,nstop) >*/
  100.     getm4_(&tabinf_1.numoff, &cirdat_1.nstop);
  101. /*<       call getm4(irpt,nstop) >*/
  102.     getm4_(&tabinf_1.irpt, &cirdat_1.nstop);
  103. /*<       call getm4(jcpt,nstop) >*/
  104.     getm4_(&tabinf_1.jcpt, &cirdat_1.nstop);
  105. /*<       call getm4(irowno,nstop) >*/
  106.     getm4_(&tabinf_1.irowno, &cirdat_1.nstop);
  107. /*<       call getm4(jcolno,nstop) >*/
  108.     getm4_(&tabinf_1.jcolno, &cirdat_1.nstop);
  109. /*<       call slpmem(irpt,nstop) >*/
  110.     slpmem_(&tabinf_1.irpt, &cirdat_1.nstop);
  111. /*<       call slpmem(jcpt,nstop) >*/
  112.     slpmem_(&tabinf_1.jcpt, &cirdat_1.nstop);
  113. /*<       call slpmem(irowno,nstop) >*/
  114.     slpmem_(&tabinf_1.irowno, &cirdat_1.nstop);
  115. /*<       call slpmem(jcolno,nstop) >*/
  116.     slpmem_(&tabinf_1.jcolno, &cirdat_1.nstop);
  117. /*<       call crunch >*/
  118.     crunch_();
  119.  
  120. /*<       call zero4(nodplc(irpt+1),nstop) >*/
  121.     zero4_(&nodplc[tabinf_1.irpt], &cirdat_1.nstop);
  122. /*<       call zero4(nodplc(jcpt+1),nstop) >*/
  123.     zero4_(&nodplc[tabinf_1.jcpt], &cirdat_1.nstop);
  124. /*<       call zero4(nodplc(irowno+1),nstop) >*/
  125.     zero4_(&nodplc[tabinf_1.irowno], &cirdat_1.nstop);
  126. /*<       call zero4(nodplc(jcolno+1),nstop) >*/
  127.     zero4_(&nodplc[tabinf_1.jcolno], &cirdat_1.nstop);
  128. /*<       call zero4(nodplc(iseq1+1),numvs) >*/
  129.     zero4_(&nodplc[tabinf_1.iseq1], &cirdat_1.numvs);
  130. /*<       call zero4(nodplc(nodevs+1),numnod) >*/
  131.     zero4_(&nodplc[tabinf_1.nodevs], &cirdat_1.numnod);
  132. /*<       call zero4(nodplc(ndiag+1),nstop) >*/
  133.     zero4_(&nodplc[tabinf_1.ndiag], &cirdat_1.nstop);
  134. /*<       call zero4(nodplc(nmoffc+1),nstop) >*/
  135.     zero4_(&nodplc[tabinf_1.nmoffc], &cirdat_1.nstop);
  136. /*<       call zero4(nodplc(numoff+1),nstop) >*/
  137.     zero4_(&nodplc[tabinf_1.numoff], &cirdat_1.nstop);
  138.  
  139. /*<       numvs=0 >*/
  140.     cirdat_1.numvs = 0;
  141. /*<       nxtrm=0 >*/
  142.     cirdat_1.nxtrm = 0;
  143. /*<       ndist=0 >*/
  144.     cirdat_1.ndist = 0;
  145. /*<       ntlin=1 >*/
  146.     cirdat_1.ntlin = 1;
  147. /*<       ibr=numnod >*/
  148.     cirdat_1.ibr = cirdat_1.numnod;
  149.  
  150. /*  resistors */
  151.  
  152. /*<       loc=locate(1) >*/
  153.     loc = cirdat_1.locate[0];
  154. /*<   110 if ((loc.eq.0).or.(nodplc(loc+8).ne.0)) go to 120 >*/
  155. L110:
  156.     if (loc == 0 || nodplc[loc + 7] != 0) {
  157.     goto L120;
  158.     }
  159. /*<       node1=nodplc(loc+2) >*/
  160.     node1 = nodplc[loc + 1];
  161. /*<       node2=nodplc(loc+3) >*/
  162.     node2 = nodplc[loc + 2];
  163. /*<       call reserv(node1,node1) >*/
  164.     reserv_(&node1, &node1);
  165. /*<       call reserv(node1,node2) >*/
  166.     reserv_(&node1, &node2);
  167. /*<       call reserv(node2,node1) >*/
  168.     reserv_(&node2, &node1);
  169. /*<       call reserv(node2,node2) >*/
  170.     reserv_(&node2, &node2);
  171. /*<       loc=nodplc(loc) >*/
  172.     loc = nodplc[loc - 1];
  173. /*<       go to 110 >*/
  174.     goto L110;
  175.  
  176. /*  capacitors */
  177.  
  178. /*<   120 loc=locate(2) >*/
  179. L120:
  180.     loc = cirdat_1.locate[1];
  181. /*<   130 if ((loc.eq.0).or.(nodplc(loc+12).ne.0)) go to 400 >*/
  182. L130:
  183.     if (loc == 0 || nodplc[loc + 11] != 0) {
  184.     goto L400;
  185.     }
  186. /*<       node1=nodplc(loc+2) >*/
  187.     node1 = nodplc[loc + 1];
  188. /*<       node2=nodplc(loc+3) >*/
  189.     node2 = nodplc[loc + 2];
  190. /*<       call reserv(node1,node2) >*/
  191.     reserv_(&node1, &node2);
  192. /*<       call reserv(node2,node1) >*/
  193.     reserv_(&node2, &node1);
  194. /*<       ntemp=nodplc(ndiag+node1) >*/
  195.     ntemp = nodplc[tabinf_1.ndiag + node1 - 1];
  196. /*<       call reserv(node1,node1) >*/
  197.     reserv_(&node1, &node1);
  198. /*<       nodplc(ndiag+node1)=ntemp >*/
  199.     nodplc[tabinf_1.ndiag + node1 - 1] = ntemp;
  200. /*<       ntemp=nodplc(ndiag+node2) >*/
  201.     ntemp = nodplc[tabinf_1.ndiag + node2 - 1];
  202. /*<       call reserv(node2,node2) >*/
  203.     reserv_(&node2, &node2);
  204. /*<       nodplc(ndiag+node2)=ntemp >*/
  205.     nodplc[tabinf_1.ndiag + node2 - 1] = ntemp;
  206. /*<       nodplc(loc+8)=nxtrm+1 >*/
  207.     nodplc[loc + 7] = cirdat_1.nxtrm + 1;
  208. /*<       nxtrm=nxtrm+2 >*/
  209.     cirdat_1.nxtrm += 2;
  210. /*<       loc=nodplc(loc) >*/
  211.     loc = nodplc[loc - 1];
  212. /*<       go to 130 >*/
  213.     goto L130;
  214.  
  215. /*  inductors */
  216.  
  217. /*<   400 loc=locate(3) >*/
  218. L400:
  219.     loc = cirdat_1.locate[2];
  220. /*<   430 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 440 >*/
  221. L430:
  222.     if (loc == 0 || nodplc[loc + 13] != 0) {
  223.     goto L440;
  224.     }
  225. /*<       node1=nodplc(loc+2) >*/
  226.     node1 = nodplc[loc + 1];
  227. /*<       node2=nodplc(loc+3) >*/
  228.     node2 = nodplc[loc + 2];
  229. /*<       ibr=ibr+1 >*/
  230.     ++cirdat_1.ibr;
  231. /*<       nodplc(loc+5)=ibr >*/
  232.     nodplc[loc + 4] = cirdat_1.ibr;
  233. /*<       call reserv(node1,ibr) >*/
  234.     reserv_(&node1, &cirdat_1.ibr);
  235. /*<       call reserv(node2,ibr) >*/
  236.     reserv_(&node2, &cirdat_1.ibr);
  237. /*<       call reserv(ibr,node1) >*/
  238.     reserv_(&cirdat_1.ibr, &node1);
  239. /*<       call reserv(ibr,node2) >*/
  240.     reserv_(&cirdat_1.ibr, &node2);
  241. /*<       ntemp=nodplc(ndiag+ibr) >*/
  242.     ntemp = nodplc[tabinf_1.ndiag + cirdat_1.ibr - 1];
  243. /*<       call reserv(ibr,ibr) >*/
  244.     reserv_(&cirdat_1.ibr, &cirdat_1.ibr);
  245. /*<       nodplc(ndiag+ibr)=ntemp >*/
  246.     nodplc[tabinf_1.ndiag + cirdat_1.ibr - 1] = ntemp;
  247. /*<       numvs=numvs+1 >*/
  248.     ++cirdat_1.numvs;
  249. /*<       nodplc(iseq+numvs)=loc >*/
  250.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  251. /*<       nodplc(neqn+numvs)=ibr >*/
  252.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = cirdat_1.ibr;
  253. /*<       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 >*/
  254.     ++nodplc[tabinf_1.nodevs + node1 - 1];
  255. /*<       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 >*/
  256.     ++nodplc[tabinf_1.nodevs + node2 - 1];
  257. /*<       nodplc(loc+11)=nxtrm+1 >*/
  258.     nodplc[loc + 10] = cirdat_1.nxtrm + 1;
  259. /*<       nxtrm=nxtrm+2 >*/
  260.     cirdat_1.nxtrm += 2;
  261. /*<       loc=nodplc(loc) >*/
  262.     loc = nodplc[loc - 1];
  263. /*<       go to 430 >*/
  264.     goto L430;
  265.  
  266. /*  mutual inductors */
  267.  
  268. /*<   440 loc=locate(4) >*/
  269. L440:
  270.     loc = cirdat_1.locate[3];
  271. /*<   450 if ((loc.eq.0).or.(nodplc(loc+6).ne.0)) go to 460 >*/
  272. L450:
  273.     if (loc == 0 || nodplc[loc + 5] != 0) {
  274.     goto L460;
  275.     }
  276. /*<       nl1=nodplc(loc+2) >*/
  277.     nl1 = nodplc[loc + 1];
  278. /*<       nl2=nodplc(loc+3) >*/
  279.     nl2 = nodplc[loc + 2];
  280. /*<       nl1=nodplc(nl1+5) >*/
  281.     nl1 = nodplc[nl1 + 4];
  282. /*<       nl2=nodplc(nl2+5) >*/
  283.     nl2 = nodplc[nl2 + 4];
  284. /*<       call reserv(nl1,nl2) >*/
  285.     reserv_(&nl1, &nl2);
  286. /*<       call reserv(nl2,nl1) >*/
  287.     reserv_(&nl2, &nl1);
  288. /*<       loc=nodplc(loc) >*/
  289.     loc = nodplc[loc - 1];
  290. /*<       go to 450 >*/
  291.     goto L450;
  292.  
  293. /*  nonlinear voltage-controlled current sources */
  294.  
  295. /*<   460 loc=locate(5) >*/
  296. L460:
  297.     loc = cirdat_1.locate[4];
  298. /*<   462 if ((loc.eq.0).or.(nodplc(loc+13).ne.0)) go to 464 >*/
  299. L462:
  300.     if (loc == 0 || nodplc[loc + 12] != 0) {
  301.     goto L464;
  302.     }
  303. /*<       node1=nodplc(loc+2) >*/
  304.     node1 = nodplc[loc + 1];
  305. /*<       node2=nodplc(loc+3) >*/
  306.     node2 = nodplc[loc + 2];
  307. /*<       ndim=nodplc(loc+4) >*/
  308.     ndim = nodplc[loc + 3];
  309. /*<       ndim2=ndim+ndim >*/
  310.     ndim2 = ndim + ndim;
  311. /*<       locn=nodplc(loc+6) >*/
  312.     locn = nodplc[loc + 5];
  313. /*<       do 463 i=1,ndim2 >*/
  314.     i_1 = ndim2;
  315.     for (i = 1; i <= i_1; ++i) {
  316. /*<       node=nodplc(locn+i) >*/
  317.     node = nodplc[locn + i - 1];
  318. /*<       call reserv(node1,node) >*/
  319.     reserv_(&node1, &node);
  320. /*<       call reserv(node2,node) >*/
  321.     reserv_(&node2, &node);
  322. /*<   463 continue >*/
  323. /* L463: */
  324.     }
  325. /*<       nodplc(loc+12)=nxtrm+1 >*/
  326.     nodplc[loc + 11] = cirdat_1.nxtrm + 1;
  327. /*<       nxtrm=nxtrm+1+ndim2 >*/
  328.     cirdat_1.nxtrm = cirdat_1.nxtrm + 1 + ndim2;
  329. /*<       loc=nodplc(loc) >*/
  330.     loc = nodplc[loc - 1];
  331. /*<       go to 462 >*/
  332.     goto L462;
  333.  
  334. /*  nonlinear voltage controlled voltage sources */
  335.  
  336. /*<   464 loc=locate(6) >*/
  337. L464:
  338.     loc = cirdat_1.locate[5];
  339. /*<   466 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 468 >*/
  340. L466:
  341.     if (loc == 0 || nodplc[loc + 13] != 0) {
  342.     goto L468;
  343.     }
  344. /*<       node1=nodplc(loc+2) >*/
  345.     node1 = nodplc[loc + 1];
  346. /*<       node2=nodplc(loc+3) >*/
  347.     node2 = nodplc[loc + 2];
  348. /*<       ibr=ibr+1 >*/
  349.     ++cirdat_1.ibr;
  350. /*<       nodplc(loc+6)=ibr >*/
  351.     nodplc[loc + 5] = cirdat_1.ibr;
  352. /*<       call reserv(node1,ibr) >*/
  353.     reserv_(&node1, &cirdat_1.ibr);
  354. /*<       call reserv(node2,ibr) >*/
  355.     reserv_(&node2, &cirdat_1.ibr);
  356. /*<       call reserv(ibr,node1) >*/
  357.     reserv_(&cirdat_1.ibr, &node1);
  358. /*<       call reserv(ibr,node2) >*/
  359.     reserv_(&cirdat_1.ibr, &node2);
  360. /*<       numvs=numvs+1 >*/
  361.     ++cirdat_1.numvs;
  362. /*<       nodplc(iseq+numvs)=loc >*/
  363.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  364. /*<       nodplc(neqn+numvs)=ibr >*/
  365.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = cirdat_1.ibr;
  366. /*<       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 >*/
  367.     ++nodplc[tabinf_1.nodevs + node1 - 1];
  368. /*<       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 >*/
  369.     ++nodplc[tabinf_1.nodevs + node2 - 1];
  370. /*<       ndim=nodplc(loc+4) >*/
  371.     ndim = nodplc[loc + 3];
  372. /*<       ndim2=ndim+ndim >*/
  373.     ndim2 = ndim + ndim;
  374. /*<       locn=nodplc(loc+7) >*/
  375.     locn = nodplc[loc + 6];
  376. /*<       do 467 i=1,ndim2 >*/
  377.     i_1 = ndim2;
  378.     for (i = 1; i <= i_1; ++i) {
  379. /*<       node=nodplc(locn+i) >*/
  380.     node = nodplc[locn + i - 1];
  381. /*<       call reserv(ibr,node) >*/
  382.     reserv_(&cirdat_1.ibr, &node);
  383. /*<   467 continue >*/
  384. /* L467: */
  385.     }
  386. /*<       nodplc(loc+13)=nxtrm+1 >*/
  387.     nodplc[loc + 12] = cirdat_1.nxtrm + 1;
  388. /*<       nxtrm=nxtrm+2+ndim2 >*/
  389.     cirdat_1.nxtrm = cirdat_1.nxtrm + 2 + ndim2;
  390. /*<       loc=nodplc(loc) >*/
  391.     loc = nodplc[loc - 1];
  392. /*<       go to 466 >*/
  393.     goto L466;
  394.  
  395. /*  voltage sources */
  396.  
  397. /*<   468 loc=locate(9) >*/
  398. L468:
  399.     loc = cirdat_1.locate[8];
  400. /*<   470 if ((loc.eq.0).or.(nodplc(loc+11).ne.0)) go to 472 >*/
  401. L470:
  402.     if (loc == 0 || nodplc[loc + 10] != 0) {
  403.     goto L472;
  404.     }
  405. /*<       node1=nodplc(loc+2) >*/
  406.     node1 = nodplc[loc + 1];
  407. /*<       node2=nodplc(loc+3) >*/
  408.     node2 = nodplc[loc + 2];
  409. /*<       ibr=ibr+1 >*/
  410.     ++cirdat_1.ibr;
  411. /*<       nodplc(loc+6)=ibr >*/
  412.     nodplc[loc + 5] = cirdat_1.ibr;
  413. /*<       call reserv(node1,ibr) >*/
  414.     reserv_(&node1, &cirdat_1.ibr);
  415. /*<       call reserv(node2,ibr) >*/
  416.     reserv_(&node2, &cirdat_1.ibr);
  417. /*<       call reserv(ibr,node1) >*/
  418.     reserv_(&cirdat_1.ibr, &node1);
  419. /*<       call reserv(ibr,node2) >*/
  420.     reserv_(&cirdat_1.ibr, &node2);
  421. /*<       numvs=numvs+1 >*/
  422.     ++cirdat_1.numvs;
  423. /*<       nodplc(iseq+numvs)=loc >*/
  424.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  425. /*<       nodplc(neqn+numvs)=ibr >*/
  426.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = cirdat_1.ibr;
  427. /*<       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 >*/
  428.     ++nodplc[tabinf_1.nodevs + node1 - 1];
  429. /*<       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 >*/
  430.     ++nodplc[tabinf_1.nodevs + node2 - 1];
  431. /*<       loc=nodplc(loc) >*/
  432.     loc = nodplc[loc - 1];
  433. /*<       go to 470 >*/
  434.     goto L470;
  435.  
  436. /*  nonlinear current controlled current sources */
  437.  
  438. /*<   472 loc=locate(7) >*/
  439. L472:
  440.     loc = cirdat_1.locate[6];
  441. /*<   474 if ((loc.eq.0).or.(nodplc(loc+13).ne.0)) go to 476 >*/
  442. L474:
  443.     if (loc == 0 || nodplc[loc + 12] != 0) {
  444.     goto L476;
  445.     }
  446. /*<       node1=nodplc(loc+2) >*/
  447.     node1 = nodplc[loc + 1];
  448. /*<       node2=nodplc(loc+3) >*/
  449.     node2 = nodplc[loc + 2];
  450. /*<       ndim=nodplc(loc+4) >*/
  451.     ndim = nodplc[loc + 3];
  452. /*<       locvs=nodplc(loc+6) >*/
  453.     locvs = nodplc[loc + 5];
  454. /*<       do 475 i=1,ndim >*/
  455.     i_1 = ndim;
  456.     for (i = 1; i <= i_1; ++i) {
  457. /*<       locvst=nodplc(locvs+i) >*/
  458.     locvst = nodplc[locvs + i - 1];
  459. /*<       kbr=nodplc(locvst+6) >*/
  460.     kbr = nodplc[locvst + 5];
  461. /*<       call reserv(node1,kbr) >*/
  462.     reserv_(&node1, &kbr);
  463. /*<       call reserv(node2,kbr) >*/
  464.     reserv_(&node2, &kbr);
  465. /*<   475 continue >*/
  466. /* L475: */
  467.     }
  468. /*<       nodplc(loc+12)=nxtrm+1 >*/
  469.     nodplc[loc + 11] = cirdat_1.nxtrm + 1;
  470. /*<       nxtrm=nxtrm+1+ndim+ndim >*/
  471.     cirdat_1.nxtrm = cirdat_1.nxtrm + 1 + ndim + ndim;
  472. /*<       loc=nodplc(loc) >*/
  473.     loc = nodplc[loc - 1];
  474. /*<       go to 474 >*/
  475.     goto L474;
  476.  
  477. /*  nonlinear current controlled voltage sources */
  478.  
  479. /*<   476 loc=locate(8) >*/
  480. L476:
  481.     loc = cirdat_1.locate[7];
  482. /*<   478 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 500 >*/
  483. L478:
  484.     if (loc == 0 || nodplc[loc + 13] != 0) {
  485.     goto L500;
  486.     }
  487. /*<       node1=nodplc(loc+2) >*/
  488.     node1 = nodplc[loc + 1];
  489. /*<       node2=nodplc(loc+3) >*/
  490.     node2 = nodplc[loc + 2];
  491. /*<       ibr=ibr+1 >*/
  492.     ++cirdat_1.ibr;
  493. /*<       nodplc(loc+6)=ibr >*/
  494.     nodplc[loc + 5] = cirdat_1.ibr;
  495. /*<       call reserv(node1,ibr) >*/
  496.     reserv_(&node1, &cirdat_1.ibr);
  497. /*<       call reserv(node2,ibr) >*/
  498.     reserv_(&node2, &cirdat_1.ibr);
  499. /*<       call reserv(ibr,node1) >*/
  500.     reserv_(&cirdat_1.ibr, &node1);
  501. /*<       call reserv(ibr,node2) >*/
  502.     reserv_(&cirdat_1.ibr, &node2);
  503. /*<       numvs=numvs+1 >*/
  504.     ++cirdat_1.numvs;
  505. /*<       nodplc(iseq+numvs)=loc >*/
  506.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  507. /*<       nodplc(neqn+numvs)=ibr >*/
  508.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = cirdat_1.ibr;
  509. /*<       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 >*/
  510.     ++nodplc[tabinf_1.nodevs + node1 - 1];
  511. /*<       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 >*/
  512.     ++nodplc[tabinf_1.nodevs + node2 - 1];
  513. /*<       ndim=nodplc(loc+4) >*/
  514.     ndim = nodplc[loc + 3];
  515. /*<       locvs=nodplc(loc+7) >*/
  516.     locvs = nodplc[loc + 6];
  517. /*<       do 479 i=1,ndim >*/
  518.     i_1 = ndim;
  519.     for (i = 1; i <= i_1; ++i) {
  520. /*<       locvst=nodplc(locvs+i) >*/
  521.     locvst = nodplc[locvs + i - 1];
  522. /*<       kbr=nodplc(locvst+6) >*/
  523.     kbr = nodplc[locvst + 5];
  524. /*<       call reserv(ibr,kbr) >*/
  525.     reserv_(&cirdat_1.ibr, &kbr);
  526. /*<   479 continue >*/
  527. /* L479: */
  528.     }
  529. /*<       nodplc(loc+13)=nxtrm+1 >*/
  530.     nodplc[loc + 12] = cirdat_1.nxtrm + 1;
  531. /*<       nxtrm=nxtrm+2+ndim+ndim >*/
  532.     cirdat_1.nxtrm = cirdat_1.nxtrm + 2 + ndim + ndim;
  533. /*<       loc=nodplc(loc) >*/
  534.     loc = nodplc[loc - 1];
  535. /*<       go to 478 >*/
  536.     goto L478;
  537.  
  538. /*  diodes */
  539.  
  540. /*<   500 loc=locate(11) >*/
  541. L500:
  542.     loc = cirdat_1.locate[10];
  543. /*<   510 if ((loc.eq.0).or.(nodplc(loc+16).ne.0)) go to 520 >*/
  544. L510:
  545.     if (loc == 0 || nodplc[loc + 15] != 0) {
  546.     goto L520;
  547.     }
  548. /*<       node1=nodplc(loc+2) >*/
  549.     node1 = nodplc[loc + 1];
  550. /*<       node2=nodplc(loc+3) >*/
  551.     node2 = nodplc[loc + 2];
  552. /*<       node3=nodplc(loc+4) >*/
  553.     node3 = nodplc[loc + 3];
  554. /*<       call reserv(node1,node1) >*/
  555.     reserv_(&node1, &node1);
  556. /*<       call reserv(node2,node2) >*/
  557.     reserv_(&node2, &node2);
  558. /*<       call reserv(node3,node3) >*/
  559.     reserv_(&node3, &node3);
  560. /*<       call reserv(node1,node3) >*/
  561.     reserv_(&node1, &node3);
  562. /*<       call reserv(node2,node3) >*/
  563.     reserv_(&node2, &node3);
  564. /*<       call reserv(node3,node1) >*/
  565.     reserv_(&node3, &node1);
  566. /*<       call reserv(node3,node2) >*/
  567.     reserv_(&node3, &node2);
  568. /*<       nodplc(loc+11)=nxtrm+1 >*/
  569.     nodplc[loc + 10] = cirdat_1.nxtrm + 1;
  570. /*<       nxtrm=nxtrm+5 >*/
  571.     cirdat_1.nxtrm += 5;
  572. /*<       nodplc(loc+12)=ndist+1 >*/
  573.     nodplc[loc + 11] = cirdat_1.ndist + 1;
  574. /*<       ndist=ndist+7 >*/
  575.     cirdat_1.ndist += 7;
  576. /*<       loc=nodplc(loc) >*/
  577.     loc = nodplc[loc - 1];
  578. /*<       go to 510 >*/
  579.     goto L510;
  580.  
  581. /*  transistors */
  582.  
  583. /*<   520 loc=locate(12) >*/
  584. L520:
  585.     loc = cirdat_1.locate[11];
  586. /*<   530 if ((loc.eq.0).or.(nodplc(loc+36).ne.0)) go to 540 >*/
  587. L530:
  588.     if (loc == 0 || nodplc[loc + 35] != 0) {
  589.     goto L540;
  590.     }
  591. /*<       node1=nodplc(loc+2) >*/
  592.     node1 = nodplc[loc + 1];
  593. /*<       node2=nodplc(loc+3) >*/
  594.     node2 = nodplc[loc + 2];
  595. /*<       node3=nodplc(loc+4) >*/
  596.     node3 = nodplc[loc + 3];
  597. /*<       node4=nodplc(loc+5) >*/
  598.     node4 = nodplc[loc + 4];
  599. /*<       node5=nodplc(loc+6) >*/
  600.     node5 = nodplc[loc + 5];
  601. /*<       node6=nodplc(loc+7) >*/
  602.     node6 = nodplc[loc + 6];
  603. /*<       node7=nodplc(loc+30) >*/
  604.     node7 = nodplc[loc + 29];
  605. /*<       locm=nodplc(loc+8) >*/
  606.     locm = nodplc[loc + 7];
  607. /*<       locm=nodplc(locm+1) >*/
  608.     locm = nodplc[locm];
  609. /*<       cdis=value(locm+32) >*/
  610.     cdis = blank_1.value[locm + 31];
  611. /*<       call reserv(node1,node1) >*/
  612.     reserv_(&node1, &node1);
  613. /*<       call reserv(node2,node2) >*/
  614.     reserv_(&node2, &node2);
  615. /*<       call reserv(node3,node3) >*/
  616.     reserv_(&node3, &node3);
  617. /*<       call reserv(node4,node4) >*/
  618.     reserv_(&node4, &node4);
  619. /*<       call reserv(node5,node5) >*/
  620.     reserv_(&node5, &node5);
  621. /*<       call reserv(node6,node6) >*/
  622.     reserv_(&node6, &node6);
  623. /*<       call reserv(node1,node4) >*/
  624.     reserv_(&node1, &node4);
  625. /*<       call reserv(node2,node5) >*/
  626.     reserv_(&node2, &node5);
  627. /*<       call reserv(node3,node6) >*/
  628.     reserv_(&node3, &node6);
  629. /*<       call reserv(node4,node5) >*/
  630.     reserv_(&node4, &node5);
  631. /*<       call reserv(node4,node6) >*/
  632.     reserv_(&node4, &node6);
  633. /*<       call reserv(node5,node6) >*/
  634.     reserv_(&node5, &node6);
  635. /*<       call reserv(node4,node1) >*/
  636.     reserv_(&node4, &node1);
  637. /*<       call reserv(node5,node2) >*/
  638.     reserv_(&node5, &node2);
  639. /*<       call reserv(node6,node3) >*/
  640.     reserv_(&node6, &node3);
  641. /*<       call reserv(node5,node4) >*/
  642.     reserv_(&node5, &node4);
  643. /*<       call reserv(node6,node4) >*/
  644.     reserv_(&node6, &node4);
  645. /*<       call reserv(node6,node5) >*/
  646.     reserv_(&node6, &node5);
  647. /*<       call reserv(node7,node7) >*/
  648.     reserv_(&node7, &node7);
  649. /*<       call reserv(node4,node7) >*/
  650.     reserv_(&node4, &node7);
  651. /*<       call reserv(node7,node4) >*/
  652.     reserv_(&node7, &node4);
  653. /*<       if (cdis.lt.1.0d0) call reserv(node2,node4) >*/
  654.     if (cdis < 1.) {
  655.     reserv_(&node2, &node4);
  656.     }
  657. /*<       if (cdis.lt.1.0d0) call reserv(node4,node2) >*/
  658.     if (cdis < 1.) {
  659.     reserv_(&node4, &node2);
  660.     }
  661. /*<       nodplc(loc+22)=nxtrm+1 >*/
  662.     nodplc[loc + 21] = cirdat_1.nxtrm + 1;
  663. /*<       nxtrm=nxtrm+19 >*/
  664.     cirdat_1.nxtrm += 19;
  665. /*<       nodplc(loc+23)=ndist+1 >*/
  666.     nodplc[loc + 22] = cirdat_1.ndist + 1;
  667. /*<       ndist=ndist+21 >*/
  668.     cirdat_1.ndist += 21;
  669. /*<       loc=nodplc(loc) >*/
  670.     loc = nodplc[loc - 1];
  671. /*<       go to 530 >*/
  672.     goto L530;
  673.  
  674. /*  jfets */
  675.  
  676. /*<   540 loc=locate(13) >*/
  677. L540:
  678.     loc = cirdat_1.locate[12];
  679. /*<   550 if ((loc.eq.0).or.(nodplc(loc+25).ne.0)) go to 560 >*/
  680. L550:
  681.     if (loc == 0 || nodplc[loc + 24] != 0) {
  682.     goto L560;
  683.     }
  684. /*<       node1=nodplc(loc+2) >*/
  685.     node1 = nodplc[loc + 1];
  686. /*<       node2=nodplc(loc+3) >*/
  687.     node2 = nodplc[loc + 2];
  688. /*<       node3=nodplc(loc+4) >*/
  689.     node3 = nodplc[loc + 3];
  690. /*<       node4=nodplc(loc+5) >*/
  691.     node4 = nodplc[loc + 4];
  692. /*<       node5=nodplc(loc+6) >*/
  693.     node5 = nodplc[loc + 5];
  694. /*<       call reserv(node1,node1) >*/
  695.     reserv_(&node1, &node1);
  696. /*<       call reserv(node2,node2) >*/
  697.     reserv_(&node2, &node2);
  698. /*<       call reserv(node3,node3) >*/
  699.     reserv_(&node3, &node3);
  700. /*<       call reserv(node4,node4) >*/
  701.     reserv_(&node4, &node4);
  702. /*<       call reserv(node5,node5) >*/
  703.     reserv_(&node5, &node5);
  704. /*<       call reserv(node1,node4) >*/
  705.     reserv_(&node1, &node4);
  706. /*<       call reserv(node2,node4) >*/
  707.     reserv_(&node2, &node4);
  708. /*<       call reserv(node2,node5) >*/
  709.     reserv_(&node2, &node5);
  710. /*<       call reserv(node3,node5) >*/
  711.     reserv_(&node3, &node5);
  712. /*<       call reserv(node4,node5) >*/
  713.     reserv_(&node4, &node5);
  714. /*<       call reserv(node4,node1) >*/
  715.     reserv_(&node4, &node1);
  716. /*<       call reserv(node4,node2) >*/
  717.     reserv_(&node4, &node2);
  718. /*<       call reserv(node5,node2) >*/
  719.     reserv_(&node5, &node2);
  720. /*<       call reserv(node5,node3) >*/
  721.     reserv_(&node5, &node3);
  722. /*<       call reserv(node5,node4) >*/
  723.     reserv_(&node5, &node4);
  724. /*<       nodplc(loc+19)=nxtrm+1 >*/
  725.     nodplc[loc + 18] = cirdat_1.nxtrm + 1;
  726. /*<       nxtrm=nxtrm+13 >*/
  727.     cirdat_1.nxtrm += 13;
  728. /*<       loc=nodplc(loc) >*/
  729.     loc = nodplc[loc - 1];
  730. /*<       go to 550 >*/
  731.     goto L550;
  732.  
  733. /*  mosfets */
  734.  
  735. /*<   560 loc=locate(14) >*/
  736. L560:
  737.     loc = cirdat_1.locate[13];
  738. /*<   570 if ((loc.eq.0).or.(nodplc(loc+33).ne.0)) go to 600 >*/
  739. L570:
  740.     if (loc == 0 || nodplc[loc + 32] != 0) {
  741.     goto L600;
  742.     }
  743. /*<       node1=nodplc(loc+2) >*/
  744.     node1 = nodplc[loc + 1];
  745. /*<       node2=nodplc(loc+3) >*/
  746.     node2 = nodplc[loc + 2];
  747. /*<       node3=nodplc(loc+4) >*/
  748.     node3 = nodplc[loc + 3];
  749. /*<       node4=nodplc(loc+5) >*/
  750.     node4 = nodplc[loc + 4];
  751. /*<       node5=nodplc(loc+6) >*/
  752.     node5 = nodplc[loc + 5];
  753. /*<       node6=nodplc(loc+7) >*/
  754.     node6 = nodplc[loc + 6];
  755. /*<       call reserv(node1,node1) >*/
  756.     reserv_(&node1, &node1);
  757. /*<       call reserv(node2,node2) >*/
  758.     reserv_(&node2, &node2);
  759. /*<       call reserv(node3,node3) >*/
  760.     reserv_(&node3, &node3);
  761. /*<       call reserv(node4,node4) >*/
  762.     reserv_(&node4, &node4);
  763. /*<       call reserv(node5,node5) >*/
  764.     reserv_(&node5, &node5);
  765. /*<       call reserv(node6,node6) >*/
  766.     reserv_(&node6, &node6);
  767. /*<       call reserv(node1,node5) >*/
  768.     reserv_(&node1, &node5);
  769. /*<       call reserv(node2,node4) >*/
  770.     reserv_(&node2, &node4);
  771. /*<       call reserv(node2,node5) >*/
  772.     reserv_(&node2, &node5);
  773. /*<       call reserv(node2,node6) >*/
  774.     reserv_(&node2, &node6);
  775. /*<       call reserv(node3,node6) >*/
  776.     reserv_(&node3, &node6);
  777. /*<       call reserv(node4,node5) >*/
  778.     reserv_(&node4, &node5);
  779. /*<       call reserv(node4,node6) >*/
  780.     reserv_(&node4, &node6);
  781. /*<       call reserv(node5,node6) >*/
  782.     reserv_(&node5, &node6);
  783. /*<       call reserv(node5,node1) >*/
  784.     reserv_(&node5, &node1);
  785. /*<       call reserv(node4,node2) >*/
  786.     reserv_(&node4, &node2);
  787. /*<       call reserv(node5,node2) >*/
  788.     reserv_(&node5, &node2);
  789. /*<       call reserv(node6,node2) >*/
  790.     reserv_(&node6, &node2);
  791. /*<       call reserv(node6,node3) >*/
  792.     reserv_(&node6, &node3);
  793. /*<       call reserv(node5,node4) >*/
  794.     reserv_(&node5, &node4);
  795. /*<       call reserv(node6,node4) >*/
  796.     reserv_(&node6, &node4);
  797. /*<       call reserv(node6,node5) >*/
  798.     reserv_(&node6, &node5);
  799. /*<       nodplc(loc+26)=nxtrm+1 >*/
  800.     nodplc[loc + 25] = cirdat_1.nxtrm + 1;
  801. /*<       nxtrm=nxtrm+28 >*/
  802.     cirdat_1.nxtrm += 28;
  803. /*<       loc=nodplc(loc) >*/
  804.     loc = nodplc[loc - 1];
  805. /*<       go to 570 >*/
  806.     goto L570;
  807.  
  808. /*  transmission lines */
  809.  
  810. /*<   600 loc=locate(17) >*/
  811. L600:
  812.     loc = cirdat_1.locate[16];
  813. /*<   610 if ((loc.eq.0).or.(nodplc(loc+33).ne.0)) go to 1000 >*/
  814. L610:
  815.     if (loc == 0 || nodplc[loc + 32] != 0) {
  816.     goto L1000;
  817.     }
  818. /*<       node1=nodplc(loc+2) >*/
  819.     node1 = nodplc[loc + 1];
  820. /*<       node2=nodplc(loc+3) >*/
  821.     node2 = nodplc[loc + 2];
  822. /*<       node3=nodplc(loc+4) >*/
  823.     node3 = nodplc[loc + 3];
  824. /*<       node4=nodplc(loc+5) >*/
  825.     node4 = nodplc[loc + 4];
  826. /*<       ni1=nodplc(loc+6) >*/
  827.     ni1 = nodplc[loc + 5];
  828. /*<       ni2=nodplc(loc+7) >*/
  829.     ni2 = nodplc[loc + 6];
  830. /*<       ibr1=ibr+1 >*/
  831.     ibr1 = cirdat_1.ibr + 1;
  832. /*<       ibr2=ibr+2 >*/
  833.     ibr2 = cirdat_1.ibr + 2;
  834. /*<       ibr=ibr+2 >*/
  835.     cirdat_1.ibr += 2;
  836. /*<       nodplc(loc+8)=ibr1 >*/
  837.     nodplc[loc + 7] = ibr1;
  838. /*<       nodplc(loc+9)=ibr2 >*/
  839.     nodplc[loc + 8] = ibr2;
  840. /*<       call reserv(node1,node1) >*/
  841.     reserv_(&node1, &node1);
  842. /*<       call reserv(node1,ni1) >*/
  843.     reserv_(&node1, &ni1);
  844. /*<       call reserv(node2,ibr1) >*/
  845.     reserv_(&node2, &ibr1);
  846. /*<       call reserv(node3,node3) >*/
  847.     reserv_(&node3, &node3);
  848. /*<       call reserv(node4,ibr2) >*/
  849.     reserv_(&node4, &ibr2);
  850. /*<       call reserv(ni1,node1) >*/
  851.     reserv_(&ni1, &node1);
  852. /*<       call reserv(ni1,ni1) >*/
  853.     reserv_(&ni1, &ni1);
  854. /*<       call reserv(ni1,ibr1) >*/
  855.     reserv_(&ni1, &ibr1);
  856. /*<       call reserv(ni2,ni2) >*/
  857.     reserv_(&ni2, &ni2);
  858. /*<       call reserv(ni2,ibr2) >*/
  859.     reserv_(&ni2, &ibr2);
  860. /*<       call reserv(ibr1,node2) >*/
  861.     reserv_(&ibr1, &node2);
  862. /*<       call reserv(ibr1,node3) >*/
  863.     reserv_(&ibr1, &node3);
  864. /*<       call reserv(ibr1,node4) >*/
  865.     reserv_(&ibr1, &node4);
  866. /*<       call reserv(ibr1,ni1) >*/
  867.     reserv_(&ibr1, &ni1);
  868. /*<       call reserv(ibr1,ibr2) >*/
  869.     reserv_(&ibr1, &ibr2);
  870. /*<       call reserv(ibr2,node1) >*/
  871.     reserv_(&ibr2, &node1);
  872. /*<       call reserv(ibr2,node2) >*/
  873.     reserv_(&ibr2, &node2);
  874. /*<       call reserv(ibr2,node4) >*/
  875.     reserv_(&ibr2, &node4);
  876. /*<       call reserv(ibr2,ni2) >*/
  877.     reserv_(&ibr2, &ni2);
  878. /*<       call reserv(ibr2,ibr1) >*/
  879.     reserv_(&ibr2, &ibr1);
  880. /*<       call reserv(node3,ni2) >*/
  881.     reserv_(&node3, &ni2);
  882. /*<       call reserv(ni2,node3) >*/
  883.     reserv_(&ni2, &node3);
  884. /*<       numvs=numvs+1 >*/
  885.     ++cirdat_1.numvs;
  886. /*<       nodplc(iseq+numvs)=loc >*/
  887.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  888. /*<       nodplc(iseq1+numvs)=1 >*/
  889.     nodplc[tabinf_1.iseq1 + cirdat_1.numvs - 1] = 1;
  890. /*<       nodplc(neqn+numvs)=ibr1 >*/
  891.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = ibr1;
  892. /*<       nodplc(nodevs+ni1)=nodplc(nodevs+ni1)+1 >*/
  893.     ++nodplc[tabinf_1.nodevs + ni1 - 1];
  894. /*<       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 >*/
  895.     ++nodplc[tabinf_1.nodevs + node2 - 1];
  896. /*<       numvs=numvs+1 >*/
  897.     ++cirdat_1.numvs;
  898. /*<       nodplc(iseq+numvs)=loc >*/
  899.     nodplc[tabinf_1.iseq + cirdat_1.numvs - 1] = loc;
  900. /*<       nodplc(iseq1+numvs)=2 >*/
  901.     nodplc[tabinf_1.iseq1 + cirdat_1.numvs - 1] = 2;
  902. /*<       nodplc(neqn+numvs)=ibr2 >*/
  903.     nodplc[tabinf_1.neqn + cirdat_1.numvs - 1] = ibr2;
  904. /*<       nodplc(nodevs+ni2)=nodplc(nodevs+ni2)+1 >*/
  905.     ++nodplc[tabinf_1.nodevs + ni2 - 1];
  906. /*<       nodplc(nodevs+node4)=nodplc(nodevs+node4)+1 >*/
  907.     ++nodplc[tabinf_1.nodevs + node4 - 1];
  908. /*<       nodplc(loc+30)=ntlin+1 >*/
  909.     nodplc[loc + 29] = cirdat_1.ntlin + 1;
  910. /*<       ntlin=ntlin+2 >*/
  911.     cirdat_1.ntlin += 2;
  912. /*<       loc=nodplc(loc) >*/
  913.     loc = nodplc[loc - 1];
  914. /*<       go to 610 >*/
  915.     goto L610;
  916.  
  917. /*  finished */
  918.  
  919. /*<  1000 return >*/
  920. L1000:
  921.     return 0;
  922. /*<       end >*/
  923. } /* matptr_ */
  924.  
  925. #undef cvalue
  926. #undef nodplc
  927.  
  928.  
  929.